package com.unicom_ng.rfid;

import android.util.Log;
//import com.orhanobut.logger.Logger;
import android.os.Looper;
import com.nativec.tools.ModuleManager;
import com.rfid.RFIDReaderHelper;
import com.rfid.ReaderConnector;
import com.rfid.bean.MessageTran;
import com.rfid.rxobserver.RXObserver;
import com.rfid.rxobserver.ReaderSetting;
import com.rfid.rxobserver.bean.RXInventoryTag;
import com.rfid.rxobserver.bean.RXOperationTag;

public class RfidUtil {

    private RFIDInterface onReceive;
    private ReaderConnector connector;
    private RFIDReaderHelper mReaderHelper;
    private boolean b;

    public static RfidUtil getInstance() {
        return InstanceHolder.instance;

    }

    static class InstanceHolder {
        public static RfidUtil instance = new RfidUtil();
    }

    /**
     * 初始化
     */
    public void init() {
        //Logger.i("init===========================");
        //上电
        up();
        //构建连接器
        connector = new ReaderConnector();
        //Logger.i("connector = new ReaderConnector();===========================");
        //连接指定串口，返回true表示成功，false失败
        b = connector.connectCom("dev/ttyS4", 115200);

        //Logger.i("b = connector.connectCom(dev/ttyS4, 115200);==========================="+b);
        if (!b) {
            judge();
//            MyToast.setNowText(b ? "连接成功" : "连接失败");
            throw new RuntimeException("连接失败");
            // return;
        }
        //  MyToast.setNowText(b ? "连接成功" : "连接失败");
        judge();
        //获取RFIDReaderHelper对象
        mReaderHelper = null;
        try {
            mReaderHelper = RFIDReaderHelper.getDefaultHelper();
            //设置天线功率
            mReaderHelper.setOutputPower((byte)0xFF,(byte)0x22);
        } catch (Exception e) {
                        e.printStackTrace();
                        throw new RuntimeException(e.getMessage());
        }
        mReaderHelper.registerObserver(rxObserver);
    }

    private void judge() {
        if (!b) {
            if (onReceive != null) {
                onReceive.fail();
            }
        }
    }

    public interface RFIDInterface {
        void onReveice(RXInventoryTag tag);

        void over();

        void fail();
    }


    public void setOnReceive(RFIDInterface onReceive) {
        this.onReceive = onReceive;
    }

    /**
     * 上电
     */
    public void up() {
        ModuleManager.newInstance().setUHFStatus(true);//模块上电
    }

    /**
     * 上电
     */
    public void down() {
        ModuleManager.newInstance().setUHFStatus(false);//模块去电
    }

    /**
     * 释放资源
     */
    public void realse() {
        ModuleManager.newInstance().release();
    }

    /**
     * 发送指令
     */
    public void command() {
        if (mReaderHelper == null) {
            return;
        }
        mReaderHelper.realTimeInventory((byte) 0xFF, (byte) 0x01);//发送实时盘存指令，更多指令参
        //Logger.i("下发盘点OK===========================");
    }

    /**
     * 销毁
     */
    public void onDestory() {
        onReceive = null;
        //移除指定RXObserver监听
        if(mReaderHelper != null && rxObserver != null){
            mReaderHelper.unRegisterObserver(rxObserver);
        }
        //停止相应的线程，关闭相应I/O资源，调用该方法后RFIDReaderHelper 的各种方法不能用，否则//会报异常，同时数据也不能同时接收。必须重新调用//connector.connectCom("dev/ttyS4",115200); RFIDReaderHelper才能正常工作
        if(connector != null){
            connector.disConnect();
        }
        //释放读写器上电掉电控制设备
        ModuleManager.newInstance().release();
    }

    RXObserver rxObserver = new RXObserver() {
        @Override
        protected void onExeCMDStatus(byte cmd, byte status) {
            Log.i("M-TAG", "onExeCMDStatus：" + cmd + " " + status);
            //如果指令没有返回额外数据仅包含命令执行的状态码（例如RFIDReaderHelper中的各种以set开头的设置指令函数，）会回调该方法
            //如果指令返回数据异常一定会回调该方法 status 为异常码
            //cmd可以用来区分具体是哪条命令的返回，命令参考CMD类文档，status指令执行状态码，参考ERROR类文档
        }

        @Override
        protected void refreshSetting(ReaderSetting readerSetting) {
            Log.i("M-TAG", "refreshSetting：" + readerSetting);
            //当发送查询读写器设置指令（例如RFIDReaderHelper中的各种以get开头的查询指令函数）会回调该方法，若有返回值会存储在readerSetting相应字段中
            //具体可以参考API文档中ReaderSetting 各个字段的含义
        }

        @Override
        protected void onInventoryTag(RXInventoryTag tag) {
            if (onReceive != null) {
                onReceive.onReveice(tag);
            }
//            Log.i("M-TAG", "" + tag.strCRC+" "+tag.strEPC+" "+tag.strFreq+" "+tag.strPC+" "+tag.strRSSI+" "+tag.btAntId);
            //当发送盘存指令的时候该方法将会回调，盘存指令包括RFIDReaderHelper中inventory，realTimeInventory，customizedSessionTargetInventory,fastSwitchAntInventory 等函数以及扣扳机
            //inventory 函数盘存到的标签会先缓存到RFID模块的缓存中，只有调用getInventoryBuffer 或 getAndResetInventoryBuffer 函数是才会回调该方法将数据上传，上传的标签数据无重复
            //当盘存到多张标签的时，该方法会多次回调，标签可以重复
        }

        @Override
        protected void onInventoryTagEnd(RXInventoryTag.RXInventoryTagEnd tagEnd) {
            if (onReceive != null) {
                onReceive.over();
            }
            //当一条盘存指令执行结束的时候该方法会回调（fastSwitchAntInventory除外fastSwitchAntInventory结束时回调onFastSwitchAntInventoryTagEnd），tagEnd为指令结束时的返回数据，具体各个字段的含义
            //可以参考文档中RXInventoryTag.RXInventoryTagEnd各个字段的含义
        }

        @Override
        protected void onFastSwitchAntInventoryTagEnd(RXInventoryTag.RXFastSwitchAntInventoryTagEnd tagEnd) {
            Log.i("M-TAG", "onFastSwitchAntInventoryTagEnd：");
            //因为fastSwitchAntInventory 函数返回的结束数据特殊，因此其单独回调这个函数
            // RXInventoryTag.RXFastSwitchAntInventoryTagEnd中各字段的含义参考API文档
        }

        @Override
        protected void onGetInventoryBufferTagCount(int nTagCount) {
            Log.i("M-TAG", "onGetInventoryBufferTagCount：");
            //通过函数getInventoryBufferTagCount 得到缓存中盘存标签的数量，数据是通过inventory盘存到读写器缓存区中标签数量，无重复标签的数量
        }

        @Override
        protected void onOperationTag(RXOperationTag tag) {
            Log.i("M-TAG", "onOperationTag：");
            //当执行readTag,writeTag,lockTag 或者 killTag 等操作标签指令函数时会回调该方法，当一次操作多张标签时会多次回调
            //返回数据RXOperationTag tag 参考API文档
        }

        @Override
        protected void onOperationTagEnd(int operationTagCount) {
            Log.i("M-TAG", "onOperationTagEnd：" + operationTagCount);
            //当执行readTag,writeTag,lockTag 或者 killTag 等操作标签指令函数结束时会回调该方法
            //operationTagCount 为操作的标签数量
        }

        @Override
        protected void onInventory6BTag(byte nAntID, String strUID) {
            Log.i("M-TAG", "onInventory6BTag：nAntID:" + nAntID + " strUID:" + strUID);
            //当执行iso180006BInventory时会回调该方法，如果盘存到多张标签会回调多次
            //nAntID 盘存的标签的天线号，strUID盘存到6B标签的UID
        }

        @Override
        protected void onInventory6BTagEnd(int nTagCount) {
            Log.i("M-TAG", "onInventory6BTagEnd：nAntID:" + nTagCount);
            //当iso180006BInventory函数执行结束，所有盘存到的6B标签数据上传完毕，会回调该方法，并传回盘存的6B标签数量
            //nTagCount 为盘存到6B标签的数量
        }

        @Override
        protected void onRead6BTag(byte antID, String strData) {
            Log.i("M-TAG", "onRead6BTag：antID:" + antID + " strData:" + strData);
            //当执行iso180006BReadTag函数时该方法会回调
            //
        }

        @Override
        protected void onWrite6BTag(byte nAntID, byte nWriteLen) {
            Log.i("M-TAG", "onWrite6BTag：");
            //当执行iso180006BWriteTag函数时该方法会回调
        }

        @Override
        protected void onLock6BTag(byte nAntID, byte nStatus) {
            Log.i("M-TAG", "onLock6BTag：");
            //当执行iso180006BLockTag函数时该方法会回调
            //nAntID 天线号 nStatus 标签Lock状态
        }

        @Override
        protected void onLockQuery6BTag(byte nAntID, byte nStatus) {
            Log.i("M-TAG", "onLockQuery6BTag：");
            //当执行iso180006BQueryLockTag函数时该方法会回调
            //nAntID 天线号 nStatus 标签Lock状态
        }

        @Override
        protected void onConfigTagMask(MessageTran msgTran) {
            Log.i("M-TAG", "onConfigTagMask：");
            //当执行setTagMask，getTagMask，clearTagMask函数时改方法会回调
            //返回数据msgTran 具体数据参考MessageTran API说明与Select指令格式
        }
    };


}
